import java.util.logging.Logger;
import org.apache.commons.codec.digest.DigestUtils;
import src.de.checker.hochzeit.domain.util.*;
import src.de.checker.hochzeit.util.*;
import src.de.checker.hochzeit.domain.user.*;
import src.de.checker.hochzeit.konstanten.*
import com.google.appengine.api.datastore.*
import static com.google.appengine.api.datastore.FetchOptions.Builder.*

Logger log = Logger.getLogger('GaesteController');

int asc = -1;
int desc = 1;
/**
 * Gästeverwaltung
 */
if(session.getAttribute(Konstanten.SESSION_USER) != null)
{
	def kquery = new Query(Konstanten.KATEGORIE)
	kquery.addSort("id", Query.SortDirection.ASCENDING)
	PreparedQuery kpreparedQuery = datastore.prepare(kquery)
	def entitiesk = kpreparedQuery.asList( withLimit(100) )
	request['listkat'] = entitiesk
	
	def rquery = new Query(Konstanten.ROLLE)
	rquery.addSort("id", Query.SortDirection.DESCENDING)
	PreparedQuery rpreparedQuery = datastore.prepare(rquery)
	def entitiesr = rpreparedQuery.asList( withLimit(100) )
	request['listrole'] = entitiesr
	
	def tquery = new Query(Konstanten.TT)
	tquery.addSort("id", Query.SortDirection.ASCENDING)
	PreparedQuery tpreparedQuery = datastore.prepare(tquery)
	def entitiest = tpreparedQuery.asList( withLimit(100) )
	request['listtt'] = entitiest
	
	if(params?.create ==~ /(?i)true/)
	{
		create()
	}
	if(params?.index ==~ /(?i)true/)
	{
		index()
	}
	if(params?.details ==~ /(?i)true/)
	{
		details()
	}
	if(params?.saveuser ==~ /(?i)true/)
	{
		saveuser()
	}
	if(params?.edit ==~ /(?i)true/)
	{
		edit()
	}
	if(params?.updateuser ==~ /(?i)true/)
	{
		update()
	}
	if(params?.updatekind ==~ /(?i)true/)
	{
		updatekind()
	}
	if(params?.updateanhang ==~ /(?i)true/)
	{
		updateanhang()
	}
	if(params?.psw ==~ /(?i)true/)
	{
		createpasswort()
	}
	if(params?.delete ==~ /(?i)true/)
	{
		delete()
	}
	if(params?.switchzusage ==~ /(?i)true/)
	{
		switchzusage()
	}
	if(params?.deletekind ==~ /(?i)true/)
	{
		deletekind()
	}
	if(params?.deleteanhang ==~ /(?i)true/)
	{
		deleteanhang()
	}
	if(params?.sendlist ==~ /(?i)true/)
	{
		sendlist()
	}
	if(params?.zugang ==~ /(?i)true/)
	{
		zugang()
	}
	if(params?.createzugang ==~ /(?i)true/)
	{
		createzugang()
	}
}



private int getOrder()
{
	private int myorder = -1;
	if(params.order && !params.order.equals('') && !params.order.equalsIgnoreCase('null'))
	{
		try
		{
			String wert = params.order
			int order = (new Integer(wert)).intValue()
			myorder = order * -1
		}
		catch(Exception e)
		{
			e.printStackTrace()
		}
	}
	
	return myorder;
}

private void create()
{
	request['email'] = ''
	request['handy'] = ''
	request['telefon'] = ''
	forward '/gaeste/create.gtpl'
}
/**
 * Sucht alle Gäste zur Feier des angemeldeten Benutzers
 */
private void index()
{
	long t1 = System.currentTimeMillis()
	String sort = ""
	int order = getOrder()
	
	def query = new Query(Konstanten.GAST)
	query.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	
	if(params.sort)
		sort = params.sort
	
	if(!sort.equals(''))
	{
		if(order == -1)
			query.addSort(sort, Query.SortDirection.ASCENDING)
		else
			query.addSort(sort, Query.SortDirection.DESCENDING)
	}
	else
	{
		query.addSort("rolle", Query.SortDirection.ASCENDING)
		query.addSort("kategorie", Query.SortDirection.ASCENDING)
		query.addSort("nachname", Query.SortDirection.ASCENDING)
		query.addSort("strasse", Query.SortDirection.ASCENDING)
	}
	
	
    PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(300) )
	request['list'] = entities
	request['size'] = entities.size()
	request['order'] = order;
	
    HashMap kinder = new HashMap()
	HashMap anhang = new HashMap()
    
    for(i in entities)
    {
    	kinder.put(i.key.id, new ArrayList())
    	List list =  new ArrayList()
    	list.add(i)
    	anhang.put(i.key.id,list)
    }
    
    def query1 = new Query(Konstanten.KIND)
    query1.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
	def entities1 = preparedQuery1.asList( withLimit(100) )
	request['ksize'] = entities1.size()
	
	def query2 = new Query(Konstanten.ANHANG)
    query2.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery2 = datastore.prepare(query2)
	def entities2 = preparedQuery2.asList( withLimit(100) )
	request['asize'] = entities2.size()
	long t2 = System.currentTimeMillis()
	
	
	for(i in entities1)
	{
		Long gast = i.gast
		ArrayList liste = kinder.get(gast)
		liste.add(i)
		kinder.put (gast, liste)
	}
    for(i in entities2)
	{
		Long gast = i.gast
		ArrayList liste = anhang.get(gast)
		liste.add(i)
		anhang.put (gast, liste)
	}
	request['kinder'] = kinder
	request['anhang'] = anhang
	forward '/gaeste/uebersicht.gtpl'
}
/**
 * Speichert einen neuen Gast für die Feier vom eingeloggten Benutzer
 */
private void saveuser()
{
	Gaeste nutzer = new Gaeste();
	nutzer.vorname = params.vorname
	nutzer.nachname = params.nachname
	nutzer.anzeigename = nutzer.vorname+' '+nutzer.nachname
	nutzer.strasse = params.strasse
	nutzer.plz = params.plz
	nutzer.ort = params.ort
	nutzer.anmerkung = params.anmerkung
	nutzer.rolle = new Long(params.rolle)
	nutzer.feier = session.getAttribute(Konstanten.SESSION_USER).feier 
	nutzer.kategorie = new Long(params.kategorie)
	nutzer.zusage = false
	nutzer.status = new Long(2)
	nutzer.anmerkungZusage = ''
		
	Entity e2 = nutzer as Entity
	e2.save()
	
	
	//E-Mail
	if(params.email && !params.email.equals(''))
	{
		Telekomm t = new Telekomm()
		t.typ = new Long(0)
		t.gast = e2.key.id
		t.wert = params.email
		
		Entity e = t as Entity
		e.save()
	}
	//Handy
	if(params.handy && !params.handy.equals(''))
	{
		Telekomm t = new Telekomm()
		t.typ = new Long(1)
		t.gast = e2.key.id
		t.wert = params.handy
		
		Entity e = t as Entity
		e.save()
	}
	//Telefon
	if(params.telefon && !params.telefon.equals(''))
	{
		Telekomm t = new Telekomm()
		t.typ = new Long(2)
		t.gast = e2.key.id
		t.wert = params.telefon
		
		Entity e = t as Entity
		e.save()
	}
	request.message = 'Gast hinzugefügt. Bringt der Gast Kinder oder eine Begleitung mit, können diese hier noch hinzugefügt werden.'
	params.key = KeyFactory.keyToString(e2.key)
	edit()
	
}

private void switchzusage()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		
		Key k = KeyFactory.stringToKey(params.key)
		def entity = datastore.get(k);
		if(entity.feier.equals(feier))
		{
			long status = entity.status
			status=(status-1)%3
			if(status < 0) {
				status = 2
			}
			System.out.println(status)
			entity['status'] = status
			entity.save()
			
			def query1 = new Query(Konstanten.KIND)
		    query1.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
			query1.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
			def entities1 = preparedQuery1.asList( withLimit(100) )
			for(i in entities1)
			{
				i.status = status
				i.save()
			}
	
			def query2 = new Query(Konstanten.ANHANG)
		    query2.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
			query2.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery2 = datastore.prepare(query2)
			def entities2 = preparedQuery2.asList( withLimit(100) )
			for(i in entities2)
			{
				i.status = status
				i.save()
			}
		}
		else
		{
			String message = "Es wurde versucht ein Status von einem Gast zu ändern, der nicht zur eigenen Feier gehört: "+entity.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.switchzusage(): Gast gehört nicht zur eigenen feier:"+entity+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Status von einem Gast zu ändern, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.switchzusage(): Gast nicht gefunden zum Zusage ändern. Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		index()
	}
	redirect '/gaeste'
}
private void edit()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def entity = datastore.get(k);
		if(entity.feier.equals(feier))
		{
			request['gast'] =  entity
			
			def query = new Query(Konstanten.TELEKOMM)
			query.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery = datastore.prepare(query)
		 	def entities = preparedQuery.asList( withLimit(100) )
			//request['tele'] = entities
		 	request['email'] = ''
			request['handy'] = ''
			request['telefon'] = ''
			for (i in entities)
			{
				if(i.typ == 0)
				{
					request['email'] = i.wert
				}
				if(i.typ == 1)
				{
					request['handy'] = i.wert
				}
				if(i.typ == 2)
				{
					request['telefon'] = i.wert
				}
			}
			
			
			def query1 = new Query(Konstanten.ANHANG)
			query1.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
		 	def entities1 = preparedQuery1.asList( withLimit(100) )
			request['anhang'] = entities1
			
			def query2 = new Query(Konstanten.KIND)
			query2.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery2 = datastore.prepare(query2)
		 	def entities2 = preparedQuery2.asList( withLimit(100) )
			request['kind'] = entities2
			
			//log.info("Anzahl der Kinder: "+entities2.size);
			
			forward '/gaeste/edit.gtpl'
		}
		else
		{
			String message = "Es wurde versucht ein Gast zu editieren, der nicht zur eigenen Feier gehört: "+entity.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.edit(): Gast gehört nicht zur eigenen feier:"+entity+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
			index()
		}
	}
	//Hier kommt man hin, wenn man am request-parameter params.key selber rumpfuscht
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast zu editieren, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.edit(): VERBOTEN: Es wurde versucht ein Gast zu editieren, den es nicht gibt. Benutzer der gesucht hat: "+myuser+" Params: "+params)
		index()
	}	
}
private void deletekind()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			Key k1 = KeyFactory.stringToKey(params.kkey)
			def mykind = datastore.get(k1);
			String name = mykind.name
			mykind.delete()
			String message = "Kind: "+name+" zu Gast "+nutzer.key
			createTracer(Konstanten.TRACER_DELETE, message)
			request.message = 'Kind '+name+' gelöscht'
		}
		else
		{
			String message = "Es wurde versucht ein Kind zu löschen, das nicht zur eigenen Feier gehört. Gast zum Kind: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.deletekind(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast-Kind zu löschen, das es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.deletekind(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		index()
	}
	edit()	
}
private void deleteanhang()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			Key k1 = KeyFactory.stringToKey(params.kkey)
			def mykind = datastore.get(k1);
			String name = mykind.name
			mykind.delete()
			String message = "Begleitung: "+name+" zu Gast "+nutzer.key
			createTracer(Konstanten.TRACER_DELETE, message)
			request.message = 'Begleitung '+name+' gelöscht'
		}
		else
		{
			String message = "Es wurde versucht eine Begleitung zu löschen, die nicht zur eigenen Feier gehört. Gast zur Begleitung: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.deletekind(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		log.warning(e.toString())
		log.warning("gaeste.gaeste.deletekind(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
	}
	
	edit()	
}
private void updatekind()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	boolean some_changed = false
		
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			//update
			if(params.kkey)
			{
				Key k1 = KeyFactory.stringToKey(params.kkey)
				
				def mykind = datastore.get(k1);
				if(!mykind.name.equals(params.name))
				{
					some_changed = true
					mykind.name = params.name
				}
				try
				{
					Long status = new Long(params.status)
					if(mykind.status != status)
					{
						mykind.status = status
						some_changed = true
					}
				}
				catch(Exception e){}
				try
				{
					Long alter = new Long(params.alter)
					if(alter != mykind.alter)
					{
						some_changed = true
						mykind.alter = alter
					}
				}
				catch(Exception e){}
				if(some_changed)
				{
					mykind.save()
					request.message = 'Kind '+mykind.name+' aktualisiert'
				}
			}
			//erstellen
			else
			{
				try
				{
					Kind ki = new Kind()
					ki.name = params.name
					ki.gast = nutzer.key.id
					ki.zusage = false
					ki.feier = session.getAttribute(Konstanten.SESSION_USER).feier
					ki.status = new Long(params.status)
					ki.anmerkungZusage = ''
						
					try
					{
						if(params.alter && !params.alter.equals('') && !params.alter.equals('null'))
							ki.alter = new Long(params.alter)
					}
					catch(Exception e){}
					
					Entity e = ki as Entity
					e.save()
					request.message = 'Neues Kind hinzugefügt'
				}
				catch(Exception e)
				{
					log.warning(e.toString())
				}
				
			}
		}
		else
		{
			String message = "Es wurde versucht ein Kind zu updaten, das nicht zur eigenen Feier gehört. Gast zum Kind: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.updatekind(): Gast/Kind gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+myuser)
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast-Kind zu updaten, das es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.updatekind(): Gast/Kind nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+myuser)
		
	}
	
	edit()	
}
private void updateanhang()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	boolean some_changed = false
	System.out.println(params)
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			//update
			if(params.kkey)
			{
				Key k1 = KeyFactory.stringToKey(params.kkey)
				
				def mykind = datastore.get(k1);
				if(!mykind.name.equals(params.name))
				{
					some_changed = true
					mykind.name = params.name
				}
				try
				{
					Long status = new Long(params.status)
					if(mykind.status != status)
					{
						mykind.status = status
						some_changed = true
					}
				}
				catch(Exception e){}
				if(some_changed)
				{
					mykind.save()
					request.message = 'Begleitung '+mykind.name+' aktualisiert'
				}
			}
			else
			{
				try
				{
					Anhang ki = new Anhang()
					ki.name = params.name
					ki.gast = nutzer.key.id
					ki.zusage = false
					ki.feier = session.getAttribute(Konstanten.SESSION_USER).feier
					ki.status = new Long(params.status)
					ki.anmerkungZusage = ''
						
					
					Entity e = ki as Entity
					e.save()
					request.message = 'Neue Begleitung hinzugefügt: '+params.name
				}
				catch(Exception e)
				{
					log.warning(e.toString())
				}
				
			}
		}
		else
		{
			String message = "Es wurde versucht eine Begleitung zu updaten, die nicht zur eigenen Feier gehört. Gast zur Begleitung: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.updateanhang(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast-Anhang zu updaten, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.updateanhang(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+params+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
	}
	
	edit()	
}

private boolean hasUserChanged(def params, Entity nutzer)
{
	if(!nutzer.vorname.equals(params.vorname))
		return true
	if(!nutzer.nachname.equals(params.nachname))
		return true
	if(!nutzer.strasse.equals(params.strasse))
		return true
	if(!nutzer.plz.equals(params.plz))
		return true
	if(!nutzer.ort.equals(params.ort))
		return true
	if(!nutzer.anmerkung.equals(params.anmerkung))
		return true
	if(!nutzer.anzeigename.equals(params.anzeigename))
		return true
	try
	{
		Long r = new Long(params.rolle)
		if(r != nutzer.rolle)
			return true
	}
	catch(Exception e){}
	try
	{
		Long r = new Long(params.kategorie)
		if(r != nutzer.kategorie)
			return true
	}
	catch(Exception e){}
	try
	{
		Long r = new Long(params.status)
		if(r != nutzer.status)
			return true
	}
	catch(Exception e){}
	return false
}
private void update()
{
	boolean some_changed = false
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def nutzer = datastore.get(k);
		if(nutzer.feier.equals(feier))
		{
			boolean changed = hasUserChanged(params, nutzer)
			if(changed)
			{
				nutzer.vorname = params.vorname
				nutzer.nachname = params.nachname
				if(params.anzeigename && !params.anzeigename.trim().equals('')) 
					nutzer.anzeigename = params.anzeigename
				else
					nutzer.anzeigename = nutzer.vorname+' '+nutzer.nachname
				nutzer.strasse = params.strasse
				nutzer.plz = params.plz
				nutzer.ort = params.ort
				nutzer.anmerkung = params.anmerkung
				nutzer.rolle = new Long(params.rolle)
				nutzer.kategorie = new Long(params.kategorie)
				nutzer.status = new Long(params.status)
				
				nutzer.save()
				some_changed = true
			}
			
			//E-Mail
			if(params.email && !params.email.equals(''))
			{
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(0))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Mailadresse zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.email))
			 			{
			 				entity.wert = params.email
			 				entity.save()
			 				some_changed = true
			 			}
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(0)
					t.gast = nutzer.key.id
					t.wert = params.email
					
					Entity e = t as Entity
					e.save()
					some_changed = true
				}
			}
			//Handy
			if(params.handy && !params.handy.equals(''))
			{
				
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(1))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Handynummer zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.handy))
			 			{
			 				entity.wert = params.handy
			 				entity.save()
			 				some_changed = true
			 			}
			 			
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(1)
					t.gast = nutzer.key.id
					t.wert = params.handy
					
					Entity e = t as Entity
					e.save()
					some_changed = true
				}
				
			}
			//Telefon
			if(params.telefon && !params.telefon.equals(''))
			{
				boolean create_new = false
				try
				{
					def query = new Query(Konstanten.TELEKOMM)
					query.addFilter("gast", Query.FilterOperator.EQUAL, nutzer.key.id)
					query.addFilter("typ", Query.FilterOperator.EQUAL, new Long(2))
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	def entity = preparedQuery.asSingleEntity()
				 	if(entity == null)
				 		create_new = true
			 		else
			 		{
			 			//Es gibt schon eine Handynummer zu dem Benutzer
			 			//und der hat sich auch verändert
			 			if(!entity.wert.equals(params.telefon))
			 			{
			 				entity.wert = params.telefon
			 				entity.save()
			 				some_changed = true
			 			}
			 		}
				}
				catch(Exception e)
				{
					create_new = true
				}
				if(create_new)
				{
					Telekomm t = new Telekomm()
					t.typ = new Long(2)
					t.gast = nutzer.key.id
					t.wert = params.telefon
					
					Entity e = t as Entity
					e.save()
					some_changed = true
				}
				
			}
		}
		else
		{
			String message = "Es wurde versucht ein Gast zu updaten, der nicht zur eigenen Feier gehört: "+nutzer.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.update(): Gast gehört nicht zur eigenen Feier:"+nutzer+" Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		}
	}
	catch(Exception e)
	{
		String message = 'Es wurde versucht ein Gast zu updaten, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.update(): Gast nicht gefunden zum updaten. Benutzer der gesucht hat: "+session.getAttribute(Konstanten.SESSION_USER))
		index()
	}
	if(some_changed)
		request.message = 'Daten des Gastes aktualisiert.'
	edit()
}

private void createpasswort()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier

	if(params.neuespasswort && !params.neuespasswort.equals(''))
	{
		//System.out.println("Es sollen Zugangsdaten für den Nutzer "+k+" erstellt werden")
		try
		{
			Key k = KeyFactory.stringToKey(params.key)
			def nutzer = datastore.get(k);
			if(nutzer.feier.equals(feier))
			{
				String psw = DigestUtils.md5Hex(params.neuespasswort)
				if(params.loginname && !params.loginname.equals(''))
				{
					def query = new Query(Konstanten.GAST)
					query.addFilter("loginname", Query.FilterOperator.EQUAL, params.loginname)
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	List<Entity> entities = preparedQuery.asList( withLimit(1) )
				 	
				 	//Es gibt bereits einen Nutzer mit diesem Loginnamen
					if(entities != null && entities.size() > 0)
					{
						Entity bekannt = entities.get(0);
						if(bekannt.key.compareTo(k) == 0) // Gehört zu dem Nutzer
						{
							
						}
						else
						{
							request.message = 'Der Loginname ist bereits vergeben.'
								
						}
					}
					else
					{
						nutzer.loginname = params.loginname
						nutzer.passwort = psw
						nutzer.save()
						request.message = 'Dem Benutzer wurde ein Zugang eingerichtet.'
						String message = "Dem Gast "+nutzer.key+" wurde vom Brautpaar ein Zugang eingerichtet. "
						createTracer(Konstanten.TRACER_CREATE , message)
						log.info("Für den Benutzer "+nutzer+" wurde ein Zugang erstellt.")
					}
				}
				else
				{
					if(nutzer.loginname && !nutzer.loginname.equals(''))
					{
						nutzer.passwort = psw
						nutzer.save()
						request.message = 'Dem Benutzer wurde ein neues Passwort zugeteilt.'
						String message = "Dem Gast "+nutzer.key+" wurde vom Brautpaar ein neues Passwort zugewiesen. "
						createTracer(Konstanten.TRACER_UPDATE , message)
						log.info("Dem Benutzer "+nutzer+" wurde ein neues Passwort zugeteilt.")
					}
					else
						request.message = 'Bitte auch ein Nutzernamen angeben.'
				}
				
			}
			else
			{
				String message = "Es wurde versucht ein Zugang für einen Gast einzurichten, der nicht zur eigenen Feier gehört: "+nutzer.key
				createTracer(Konstanten.TRACER_VERBOTEN, message)
				log.warning('Der Benutzer '+nutzer+' für den das Passwort geändert werden soll gehört nicht zur Feier von '+session.getAttribute(Konstanten.SESSION_USER))
			}
		}
		catch(Exception e)
		{
			String message = 'Es wurde versucht ein Zugang für einen Gast zu erstellen, den es nicht gibt. params.key: '+params.key 
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("FEs wurde versucht ein Zugang für einen Gast zu erstellen, den es nicht gibt. "+params)
		}
	}
	else
		request.message = 'Bitte Passwort angeben.'
	edit()
}
private void delete()
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	try
	{
		Key k = KeyFactory.stringToKey(params.key)
		def entity = datastore.get(k);
		if(entity.feier.equals(feier))
		{
			def query = new Query(Konstanten.TELEKOMM)
			query.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery = datastore.prepare(query)
		 	def entities = preparedQuery.asList( withLimit(100) )
			for(i in entities)
			{
				i.delete()
			}
			
			def query1 = new Query(Konstanten.ANHANG)
			query1.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery1 = datastore.prepare(query1)
		 	def entities1 = preparedQuery1.asList( withLimit(100) )
			for(i in entities1)
			{
				i.delete()
			}
			
			def query2 = new Query(Konstanten.KIND)
			query2.addFilter("gast", Query.FilterOperator.EQUAL, entity.key.id)
			PreparedQuery preparedQuery2 = datastore.prepare(query2)
		 	def entities2 = preparedQuery2.asList( withLimit(100) )
			for(i in entities2)
			{
				i.delete()
			}
			log.info ('Lösche Gast: '+entity+' [Gelöscht von: '+myuser+"]")
			String message = "Gast (und zug. Telekomm, Anhang, Kind) wurde gelöscht: "+entity.vorname+" "+entity.nachname+" ["+entity.key+"]"
			createTracer(Konstanten.TRACER_UPDATE , message)
			
			entity.delete()
		}
		else
		{
			String message = "Es wurde versucht ein Gast zu löschen, der nicht zur eigenen Feier gehört: "+entity.key
			createTracer(Konstanten.TRACER_VERBOTEN, message)
			log.warning("gaeste.gaeste.delete(): Gast gehört nicht zur eigenen Feier:"+entity+" Benutzer der gesucht hat: "+myuser)
		}
	}
	catch(Exception e)
	{
		String message = 'Der Benutzer will einen Gast löschen, den es nicht gibt. params.key: '+params.key 
		createTracer(Konstanten.TRACER_VERBOTEN, message)
		log.warning(e.toString())
		log.warning("gaeste.gaeste.delete(): Gast nicht gefunden zum löschen. Benutzer der gesucht hat: "+myuser)
	}
	redirect '/gaeste'
}
/**
 * Zeigt Details zu den Gästen der eigenen Feier an
 */
private void details()
{
	long t1 = System.currentTimeMillis()
	
	//Gäste zählen, die zu der Feier gehören
	def query = new Query(Konstanten.GAST)
	query.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(1000) )
	request['list'] = entities
	request['size'] = entities.size()
	request['order'] = order;
	
    int zusage = 0;
    int absage = 0;
    int unbekannt = 0;
    for(i in entities)
    {
    	if(i.status == 0)
    		absage++
    	if(i.status == 1)
    		zusage++
    	if(i.status == 2)
    		unbekannt++
    }
    request['absage'] = absage
    request['zusage'] = zusage
    request['unbekannt'] = unbekannt
    
    //Kinder zählen, die zu der Feier gehören
    def query1 = new Query(Konstanten.KIND)
    query1.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
	def entities1 = preparedQuery1.asList( withLimit(100) )
	request['ksize'] = entities1.size()
	
	int zusagek = 0;
    int absagek = 0;
    int unbekanntk = 0;
    for(i in entities1)
    {
    	if(i.status == 0)
    		absagek++
    	if(i.status == 1)
    		zusagek++
    	if(i.status == 2)
    		unbekanntk++
    }
    request['absagek'] = absagek
    request['zusagek'] = zusagek
    request['unbekanntk'] = unbekanntk
    
	def query2 = new Query(Konstanten.ANHANG)
    query2.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	PreparedQuery preparedQuery2 = datastore.prepare(query2)
	def entities2 = preparedQuery2.asList( withLimit(100) )
	request['asize'] = entities2.size()
	long t2 = System.currentTimeMillis()
	
	int zusagea = 0;
    int absagea = 0;
    int unbekannta = 0;
    for(i in entities2)
    {
    	if(i.status == 0)
    		absagea++
    	if(i.status == 1)
    		zusagea++
    	if(i.status == 2)
    		unbekannta++
    }
    request['absagea'] = absagea
    request['zusagea'] = zusagea
    request['unbekannta'] = unbekannta
    
	forward '/gaeste/details.gtpl'
}
/**
 * Versendet die Gästeliste an den eingeloggten Benutzer
 */
private void sendlist()
{
	//System.out.println(params)
	def myuser = session.getAttribute(Konstanten.SESSION_USER)
	//Der Benutzer ist auch in der Rolle Brautpaar
	if(myuser.rolle == 0)
	{
		//E-Mail Adresse raussuchen
		def query1 = new Query(Konstanten.TELEKOMM)
		query1.addFilter("gast", Query.FilterOperator.EQUAL, myuser.key.id)
		query1.addFilter("typ", Query.FilterOperator.EQUAL, new Long(0))
		PreparedQuery preparedQuery1 = datastore.prepare(query1)
		def entities1 = preparedQuery1.asList( withLimit(1) )
		//E-Mail Adresse gefunden
		if(entities1 && entities1.size() > 0)
		{
			
		 	String mailadresse = entities1.get(0).wert
			//Alle Gäste der Hochzeitsfeier suchen
			def query = new Query(Konstanten.GAST)
			query.addFilter("feier", Query.FilterOperator.EQUAL, myuser.feier)
			query.addSort("nachname", Query.SortDirection.ASCENDING)
			query.addSort("strasse", Query.SortDirection.ASCENDING)
			PreparedQuery preparedQuery = datastore.prepare(query)
		 	def entities = preparedQuery.asList( withLimit(1000) )
		 	String all = 'Name, '
		 	if(params.adresse)
		 		all +='Straße, Ort, '
		 	if(params.telefon)
		 		all +='Telefon, '
			if(params.handy)
		 		all +='Handy, '
			if(params.email)
		 		all +='E-Mail, '
 			if(params.anhang)
				all +='Begleitung, '
			if(params.kind)
				all +='Kinder, '
		 	if(params.anmerkung)
				all +='Anmerkung, '
		 	if(params.zusage)
				all +='Status der Zusage, '
		 	if(params.kategorie)
				all +='Kategorie, '
		 	all+='\n\n'
			for( i in entities)
		 	{
		 		def queryt = new Query(Konstanten.TELEKOMM)
				queryt.addFilter("gast", Query.FilterOperator.EQUAL, i.key.id)
				PreparedQuery preparedQueryt = datastore.prepare(queryt)
			 	def entitiest = preparedQueryt.asList( withLimit(3) )
			 	
		 		all += i.nachname+' '+i.vorname+', '
		 		
		 		if(params.adresse)
		 		{
		 			all += i.strasse+', '+i.plz+' '+i.ort+', '
		 			
		 		}
		 		if(params.telefon)
		 		{
		 			//all +='Telefon: '
		 			boolean found = false
		 			for(j in entitiest)
		 			{
		 				if(j.typ == 2)
		 				{
		 					all += j.wert+', '
		 					found = true
		 				}
		 			}
		 			if(!found)
	 					all += ' , '
		 		}
		 		if(params.handy)
		 		{
		 			//all +='Handy: '
		 			boolean found = false
		 			for(j in entitiest)
		 			{
		 				if(j.typ == 1)
		 				{
		 					all += j.wert+', '
		 					found = true
		 				}
		 			}
		 			if(!found)
	 					all += ' , '
	 			
		 		}
		 		if(params.email)
		 		{
		 			//all +='E-Mail: '
		 			boolean found = false
		 			for(j in entitiest)
		 			{
		 				if(j.typ == 0)
		 				{
		 					all += j.wert+', '
		 					found = true
		 				}
		 			}
		 			if(!found)
	 					all += ' , '
	 			
		 		}
		 		if(params.anhang)
		 		{
		 			def query2 = new Query(Konstanten.ANHANG)
		 		    query2.addFilter("feier", Query.FilterOperator.EQUAL, myuser.feier)
		 		    query2.addFilter("gast", Query.FilterOperator.EQUAL, i.key.id)
		 			PreparedQuery preparedQuery2 = datastore.prepare(query2)
		 			def entities2 = preparedQuery2.asList( withLimit(100) )
		 			if(entities2)
		 			{
		 				for(x in entities2) {
		 					all += ''+x.name+' '
		 				}
		 			}
		 			all += ', '
		 		}
		 		if(params.kind)
		 		{
		 			def query3 = new Query(Konstanten.KIND)
		 		    query3.addFilter("feier", Query.FilterOperator.EQUAL, myuser.feier)
		 		    query3.addFilter("gast", Query.FilterOperator.EQUAL, i.key.id)
		 			PreparedQuery preparedQuery3 = datastore.prepare(query3)
		 			def entities3 = preparedQuery3.asList( withLimit(100) )
		 			if(entities3)
		 			{
		 				for(x in entities3) {
		 					all += ''+x.name+' '
		 				}
		 			}
		 			all += ', '
		 			
		 		}
		 		if(params.anmerkung)
		 		{
		 			//all +='Anmerkung: '+i.anmerkung+', '
		 			all +=i.anmerkung+', '
		 		}
		 		if(params.zusage)
		 		{
		 			//all +='Status der Zusage: '
		 			if(i.status == 0)
		 				all += 'Abgesagt'
		 			if(i.status == 1)
						all += 'Zugesagt'
					if(i.status == 2)
						all += 'Unbekannt'
					all += ', '
		 		}
		 		if(params.kategorie)
		 		{
		 			//all +='Kategorie: '
		 			if(i.kategorie == 0)
		 				all += 'Familie'
		 			if(i.kategorie == 1)
						all += 'Freunde'
					if(i.kategorie == 2)
						all += 'Bekannte'
					all += ', '
		 		}
		 		if(all.endsWith(', '))
		 			all = all.substring(0,all.length()-2)
		 		all+='\n'
		 	}
			//System.out.println(all)
			
			log.info('Versende Mail mit allen Gästedaten an: '+mailadresse+'. Gast der das angefordert hat: '+myuser)
			try
			{
				mail.send sender: Konstanten.EMAIL_NO_REPLY,
				        to: mailadresse,
				        subject: "Gästeliste",
				        textBody: "Im Anhang befindet sich die Gästeliste. \nDie Liste ist im Zeichensatz ISO-8859-1 verfasst und kann mit Excel oder Open Office Calc als komma-getrennte Liste geöffnet werden, so dass Name, Adresse, etc. jeweils in einer Spalte stehen.",
				        attachment: [data: all.getBytes("ISO8859_1"), fileName: "Gästeliste.txt"]
	            
				String message = 'Gästeliste als E-Mail angefordert. Versendet an: '+mailadresse
				createTracer(Konstanten.TRACER_EMAIL, message)
				request.message = 'E-Mail erfolgreich versendet.'
			}
			catch(Exception e)
			{
				e.printStackTrace()
			}
		}
		else
		{
			request.message = 'Es ist keine E-Mail Adresse für dich hinterlegt.'
		}
	}
	else
	{
		log.warning('Ein Gast der Hochzeit, der nicht Brautpaar ist hat die Gästeliste angefordert!'+myuser)
		String message = "Der Gast hat die Gästeliste als E-Mail angefordert, obwohl er nicht zum Brautpaar gehört "+myuser.key
		createTracer(Konstanten.TRACER_VERBOTEN, message)
	}
	details()
}
private void zugang()
{
	def query = new Query(Konstanten.GAST)
	query.addFilter("feier", Query.FilterOperator.EQUAL, session.getAttribute(Konstanten.SESSION_USER).feier)
	query.addFilter("loginname", Query.FilterOperator.EQUAL, null)
	query.addSort("rolle", Query.SortDirection.ASCENDING)
	query.addSort("nachname", Query.SortDirection.ASCENDING)
	query.addSort("strasse", Query.SortDirection.ASCENDING)
	PreparedQuery preparedQuery = datastore.prepare(query)
 	def entities = preparedQuery.asList( withLimit(300) )
 	request['list'] = entities
	forward '/gaeste/zugang.gtpl'
}
private void createzugang()
{
	System.out.println(params)
	
	def myuser = session.getAttribute(Konstanten.SESSION_USER);
	String feier = myuser.feier
	
	def keys = params.key
	def names = params.loginname
	def psw = params.passwort
	int counter = 0;
	String email = "Die folgenden Zugänge für deine Feier wurden erstellt:\n\n"
	String anhang = "Name, Loginname, Passwort\n\n"	
	String error = "Folgende Loginnamen existieren schon, bitte neue wählen:"
	int erstellt = 0 
	//nur eins
	if(keys instanceof String)
	{
		if(names && psw)
		{
			try
			{
				Key k = KeyFactory.stringToKey(keys)
				def entity = datastore.get(k);
				if(entity.feier.equals(feier))
				{
					def query = new Query(Konstanten.GAST)
					query.addFilter("loginname", Query.FilterOperator.EQUAL, names)
					PreparedQuery preparedQuery = datastore.prepare(query)
				 	List<Entity> entities = preparedQuery.asList( withLimit(1) )
				 	
				 	//Es gibt bereits einen Nutzer mit diesem Loginnamen
					if(entities != null && entities.size() > 0)
					{
						error += ' [Gast: '+entity.vorname+' '+entity.nachname+',Login:'+names+'],'
					}
					else
					{
						String myp = DigestUtils.md5Hex(psw)
						entity.loginname = names
						entity.passwort = myp
						entity.save()
						erstellt++
						email += entity.nachname+' '+entity.vorname+': Loginname='+names+' Passwort='+psw+'\n'
						anhang +=entity.nachname+' '+entity.vorname+', '+names+', '+psw+'\n'
						String messaget = "Dem Gast "+entity.key+" wurde vom Brautpaar ein Zugang eingerichtet. "
						createTracer(Konstanten.TRACER_CREATE , messaget)
					}
				}
				else
				{
					String message = 'Der Benutzer einen Zugang für einen Gast erstellen, die nicht zur eigenen Feier gehört: '+entity.key
					createTracer(Konstanten.TRACER_VERBOTEN, message)
					log.warning('Benutzer '+myuser.anzeigename+' ['+myuser.key+'] hat einen Zugang für einen Gast zu erstellen' +
							' der nicht zur eigenen Feier gehört. Gast: '+entity.key)
					index()
				}
			}
			catch(Exception e)
			{
				String message = 'Der Benutzer einen Zugang für einen Gast erstellen, den es nicht gibt: '+keys
				createTracer(Konstanten.TRACER_VERBOTEN, message)
				log.warning('Benutzer '+myuser.anzeigename+' ['+myuser.key+'] hat einen Zugang für einen Gast zu erstellen' +
						' den es nicht gibt: '+keys)
			}
		}
	}
	else
	{
		for (i in keys)
		{
			String l1 = names[counter]
			String p1 = psw[counter]
			//Nur wenn beide Werte auch ausgefüllt sind speichern
			if(l1 && p1)
			{
				try
				{
					Key k = KeyFactory.stringToKey(i)
					def entity = datastore.get(k);
					//Der Gast gehört auch zur eigenen Feier
					if(entity.feier.equals(feier))
					{
						def query = new Query(Konstanten.GAST)
						query.addFilter("loginname", Query.FilterOperator.EQUAL, l1)
						PreparedQuery preparedQuery = datastore.prepare(query)
					 	List<Entity> entities = preparedQuery.asList( withLimit(1) )
					 	
					 	//Es gibt bereits einen Nutzer mit diesem Loginnamen
						if(entities != null && entities.size() > 0)
						{
							error += ' [Gast: '+entity.vorname+' '+entity.nachname+',Login:'+l1+'],'
						}
						else
						{
							String myp = DigestUtils.md5Hex(p1)
							entity.loginname = l1
							entity.passwort = myp
							entity.save()
							erstellt++
							email += entity.nachname+' '+entity.vorname+': Loginname='+l1+' Passwort='+p1+'\n'
							anhang +=entity.nachname+' '+entity.vorname+', '+l1+', '+p1+'\n'
							String messaget = "Dem Gast "+entity.key+" wurde vom Brautpaar ein Zugang eingerichtet. "
							createTracer(Konstanten.TRACER_CREATE , messaget)
						}
					}
					else
					{
						String message = 'Der Benutzer einen Zugang für einen Gast erstellen, die nicht zur eigenen Feier gehört: '+entity.key
						createTracer(Konstanten.TRACER_VERBOTEN, message)
						log.warning('Benutzer '+myuser.anzeigename+' ['+myuser.key+'] hat einen Zugang für einen Gast zu erstellen' +
								' der nicht zur eigenen Feier gehört. Gast: '+entity.key)
						index()
					}
				}
				catch(Exception ex)
				{
					String message = 'Der Benutzer einen Zugang für einen Gast erstellen, den es nicht gibt: '+i
					createTracer(Konstanten.TRACER_VERBOTEN, message)
					log.warning('Benutzer '+myuser.anzeigename+' ['+myuser.key+'] hat einen Zugang für einen Gast zu erstellen' +
							' den es nicht gibt: '+i)
				}
			}
			counter++
		}
	}
	
	if (erstellt > 0)
	{
		if(erstellt == 1)
			request.message = 'Es wurde '+erstellt+' Zugang erstellt.'
		else
			request.message = 'Es wurden '+erstellt+' Zugänge erstellt.'
	}
	
	if(error.endsWith(','))
	{
		error = error.substring(0,error.length()-1)
		if(request.message)
			request.message += error
		else
			request.message = error
	}
	
	sendMail("Zugänge", email, anhang, new Long(7))
	zugang()
}
private void sendMail(String headline, String message, String anhang, Long typ)
{
	def myuser = session.getAttribute(Konstanten.SESSION_USER)
	def mkey = myuser.key
	
	//E-Mail Adresse raussuchen
 	def query1 = new Query(Konstanten.TELEKOMM)
	query1.addFilter("gast", Query.FilterOperator.EQUAL, mkey.id)
	query1.addFilter("typ", Query.FilterOperator.EQUAL, new Long(0))
	PreparedQuery preparedQuery1 = datastore.prepare(query1)
	def entities1 = preparedQuery1.asList( withLimit(1) )
	if(entities1 && entities1.size() > 0)
	{
		def ma = entities1.get(0) 
		if(ma && ma.wert?.contains('@'))
		{
			log.info('Versende Mail an: '+ma.wert+' Typ: '+typ)
			createTracer(Konstanten.TRACER_EMAIL ,'Versende Mail an: '+ma.wert+' Typ: '+typ)
			try
			{
				mail.send sender: Konstanten.EMAIL_NO_REPLY,
						  to: ma.wert,
						  subject: headline,
						  textBody: message,
						  attachment: [data: anhang.getBytes("ISO8859_1"), fileName: "Zugänge.txt"]
			}
			catch(Exception e)
			{
				e.printStackTrace()
			}
		 }
		 else
		 	log.info(' Keine gültige Mailadresse gefunden ')
	}
	else
		log.info(' Keine Mailadresse gefunden für ' +i.vorname+' '+i.nachname)
 		
}

private void createTracer(String message)
{
	createTracer(Konstanten.TRACER_FORGOT, message);
}
private void createTracer(String type, String message) {
	try
	{
		def myuser = session.getAttribute(Konstanten.SESSION_USER);

		Tracer t = new Tracer()
	    t.ipadresse = request.getRemoteAddr()
	    t.user = myuser.key
	    t.type = type
	    t.nachricht = message
	    t.datum = Datehelper.getNow()
	    Entity e2 = t as Entity
		e2.save()
	}
	catch(Exception e)
	{
		
	}
}